home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 PPC / Lib / pstats.py < prev    next >
Encoding:
Text File  |  1996-05-19  |  16.0 KB  |  395 lines  |  [TEXT/Pyth]
  1. #
  2. # Class for printing reports on profiled python code. rev 1.0  4/1/94
  3. #
  4. # Based on prior profile module by Sjoerd Mullender...
  5. #   which was hacked somewhat by: Guido van Rossum
  6. #
  7. # see jprofile.doc and jprofile.py for more info.
  8.  
  9. # Copyright 1994, by InfoSeek Corporation, all rights reserved.
  10. # Written by James Roskind
  11. # 
  12. # Permission to use, copy, modify, and distribute this Python software
  13. # and its associated documentation for any purpose (subject to the
  14. # restriction in the following sentence) without fee is hereby granted,
  15. # provided that the above copyright notice appears in all copies, and
  16. # that both that copyright notice and this permission notice appear in
  17. # supporting documentation, and that the name of InfoSeek not be used in
  18. # advertising or publicity pertaining to distribution of the software
  19. # without specific, written prior permission.  This permission is
  20. # explicitly restricted to the copying and modification of the software
  21. # to remain in Python, compiled Python, or other languages (such as C)
  22. # wherein the modified or derived code is exclusively imported into a
  23. # Python module.
  24. # 
  25. # INFOSEEK CORPORATION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  26. # SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  27. # FITNESS. IN NO EVENT SHALL INFOSEEK CORPORATION BE LIABLE FOR ANY
  28. # SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  29. # RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  30. # CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  31. # CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  32.  
  33.  
  34. import os
  35. import time
  36. import string
  37. import marshal
  38. import regex
  39.  
  40. #**************************************************************************
  41. # Class Stats documentation
  42. #**************************************************************************
  43. # This class is used for creating reports from data generated by the
  44. # Profile class.  It is a "friend" of that class, and imports data either
  45. # by direct access to members of Profile class, or by reading in a dictionary
  46. # that was emitted (via marshal) from the Profile class.
  47. #
  48. # The big change from the previous Profiler (in terms of raw functionality)
  49. # is that an "add()" method has been provided to combine Stats from
  50. # several distinct profile runs.  Both the constructor and the add()
  51. # method now take arbitrarilly many file names as arguments.
  52. #
  53. # All the print methods now take an argument that indicats how many lines
  54. # to print.  If the arg is a floating point number between 0 and 1.0, then
  55. # it is taken as a decimal percentage of the availabel lines to be printed
  56. # (e.g., .1 means print 10% of all available lines).  If it is an integer,
  57. # it is taken to mean the number of lines of data that you wish to have
  58. # printed.
  59. #
  60. # The sort_stats() method now processes some additionaly options (i.e., in
  61. # addition to the old -1, 0, 1, or 2).  It takes an arbitrary number of quoted
  62. # strings to select the sort order.  For example sort_stats('time', 'name')
  63. # sorts on the major key of "internal function time", and on the minor
  64. # key of 'the name of the function'.  Look at the two tables in sort_stats()
  65. # and get_sort_arg_defs(self) for more examples.
  66. #
  67. # All methods now return "self",  so you can string together commands like:
  68. #    Stats('foo', 'goo').strip_dirs().sort_stats('calls').\
  69. #                               print_stats(5).print_callers(5)
  70. # 
  71. #**************************************************************************
  72. import fpformat
  73.  
  74. class Stats:
  75.     def __init__(self, *args):
  76.         if not len(args):
  77.             arg = None
  78.         else:
  79.             arg = args[0]
  80.             args = args[1:]
  81.         self.init(arg)
  82.         apply(self.add, args).ignore()
  83.             
  84.     def init(self, arg):
  85.         self.all_callees = None  # calc only if needed
  86.         self.files = []
  87.         self.fcn_list = None
  88.         self.total_tt = 0
  89.         self.total_calls = 0
  90.         self.prim_calls = 0
  91.         self.max_name_len = 0
  92.         self.top_level = {}
  93.         self.stats = {}
  94.         self.sort_arg_dict = {}
  95.         self.load_stats(arg)
  96.         trouble = 1
  97.         try:
  98.             self.get_top_level_stats()
  99.             trouble = 0
  100.         finally:
  101.             if trouble:
  102.                 print "Invalid timing data",
  103.                 if self.files: print self.files[-1],
  104.                 print
  105.  
  106.  
  107.     def load_stats(self, arg):
  108.         if not arg:  self.stats = {}
  109.         elif type(arg) == type(""):
  110.             f = open(arg, 'r')
  111.             self.stats = marshal.load(f)
  112.             f.close()
  113.             try:
  114.                 file_stats = os.stat(arg)
  115.                 arg = time.ctime(file_stats[8]) + "    " + arg
  116.             except:  # in case this is not unix
  117.                 pass
  118.             self.files = [ arg ]
  119.         elif hasattr(arg, 'create_stats'):
  120.             arg.create_stats()
  121.             self.stats = arg.stats
  122.             arg.stats = {}
  123.         if not self.stats:
  124.             raise TypeError,  "Cannot create or construct a " \
  125.                   + `self.__class__` \
  126.                   + " object from '" + `arg` + "'"
  127.         return
  128.  
  129.     def get_top_level_stats(self):
  130.         for func in self.stats.keys():
  131.             cc, nc, tt, ct, callers = self.stats[func]
  132.             self.total_calls = self.total_calls + nc
  133.             self.prim_calls  = self.prim_calls  + cc
  134.             self.total_tt    = self.total_tt    + tt
  135.             if callers.has_key(("jprofile", 0, "profiler")):
  136.                 self.top_level[func] = None
  137.             if len(func_std_string(func)) > self.max_name_len:
  138.                 self.max_name_len = len(func_std_string(func))
  139.                     
  140.     def add(self, *arg_list):
  141.         if not arg_list: return self
  142.         if len(arg_list) > 1: apply(self.add, arg_list[1:])
  143.         other = arg_list[0]
  144.         if type(self) != type(other) or \
  145.               self.__class__ != other.__class__:
  146.             other = Stats(other)
  147.         self.files = self.files + other.files
  148.         self.total_calls = self.total_calls + other.total_calls
  149.         self.prim_calls = self.prim_calls + other.prim_calls
  150.         self.total_tt = self.total_tt + other.total_tt
  151.         for func in other.top_level.keys():
  152.             self.top_level[func] = None
  153.  
  154.         if self.max_name_len < other.max_name_len:
  155.             self.max_name_len = other.max_name_len
  156.  
  157.         self.fcn_list = None
  158.  
  159.         for func in other.stats.keys():
  160.             if self.stats.has_key(func):
  161.                 old_func_stat = self.stats[func]
  162.             else:
  163.                 old_func_stat = (0, 0, 0, 0, {},)
  164.             self.stats[func] = add_func_stats(old_func_stat, \
  165.                   other.stats[func])
  166.         return self
  167.             
  168.  
  169.  
  170.     # list the tuple indicies and directions for sorting,
  171.     # along with some printable description
  172.     sort_arg_dict_default (sel) == type(1) and 0 <= sel < count:
  173.                 count = sel
  174.                 new_list = list[:count]
  175.         if len(list) != len(new_list):
  176.             msg = msg + "   List reduced from " + `len(list)` \
  177.                   + " to " + `len(new_list)` + \
  178.                   " due to restriction <" + `sel` + ">\n"
  179.             
  180.         return new_list, msg
  181.  
  182.  
  183.  
  184.     def get_print_list(self, sel_list):
  185.         width = self.max_name_len
  186.         if self.fcn_list:
  187.             list = self.fcn_list[:]
  188.             msg = "   Ordered by: " + self.sort_type + '\n'
  189.         else:
  190.             list = self.stats.keys()
  191.             msg = "   Random listing order was used\n"
  192.  
  193.         for selection in sel_list:
  194.             list,msg = self.eval_print_amount(selection, list, msg)
  195.  
  196.         count = len(list)
  197.  
  198.         if not list:
  199.             return 0, list
  200.         print msg
  201.         if count < len(self.stats):
  202.             width = 0
  203.             for func in list:
  204.                 if  len(func_std_string(func)) > width:
  205.                     width = len(func_std_string(func))
  206.         return width+2, list
  207.         
  208.     def print_stats(self, *amount):
  209.         for filename in self.files:
  210.             print filename
  211.         if self.files: print
  212.         indent = "        "
  213.         for func in self.top_level.keys():
  214.             print indent, func_get_function_name(func)
  215.         
  216.         print  indent, self.total_calls, "function calls",
  217.         if self.total_calls != self.prim_calls:
  218.             print "(" + `self.prim_calls`, "primitive calls)", 
  219.         print "in", fpformat.fix(self.total_tt, 3), "CPU seconds"
  220.         print
  221.         width, list = self.get_print_list(amount)
  222.         if list:
  223.             self.print_title()
  224.             for func in list:
  225.                 self.print_line(func)
  226.             print 
  227.             print
  228.         return self
  229.  
  230.             
  231.     def print_callees(self, *amount):
  232.         width, list = self.get_print_list(amount)
  233.         if list:
  234.             self.calc_callees()
  235.  
  236.             self.print_call_heading(width, "called...")
  237.             for func in list:
  238.                 if self.all_callees.has_key(func):
  239.                     self.print_call_line(width, \
  240.                           func, self.all_callees[func])
  241.                 else:
  242.                     self.print_call_line(width, func, {})
  243.             print
  244.             print
  245.         return self
  246.  
  247.     def print_callers(self, *amount):
  248.         width, list = self.get_print_list(amount)
  249.         if list:
  250.             self.print_call_heading(width, "was called by...")
  251.             for func in list:
  252.                 cc, nc, tt, ct, callers = self.stats[func]
  253.                 self.print_call_line(width, func, callers)
  254.             print
  255.             print
  256.         return self
  257.  
  258.     def print_call_heading(self, name_size, column_title):
  259.         print string.ljust("Function ", name_size) + column_title
  260.  
  261.  
  262.     def print_call_line(self, name_size, source, call_dict):
  263.         print string.ljust(func_std_string(source), name_size),
  264.         if not call_dict:
  265.             print "--"
  266.             return
  267.         clist = call_dict.keys()
  268.         clist.sort()
  269.         name_size = name_size + 1
  270.         indent = ""
  271.         for func in clist:
  272.             name = func_std_string(func)
  273.             print indent*name_size + name + '(' \
  274.                   + `call_dict[func]`+')', \
  275.                   f8(self.stats[func][3])
  276.             indent = " "
  277.  
  278.  
  279.  
  280.     def print_title(self):
  281.         print string.rjust('ncalls', 9),
  282.         print string.rjust('tottime', 8),
  283.         print string.rjust('percall', 8),
  284.         print string.rjust('cumtime', 8),
  285.         print string.rjust('percall', 8),
  286.         print 'filename:lineno(function)'
  287.  
  288.  
  289.     def print_line(self, func):  # hack : should print percentages
  290.         cc, nc, tt, ct, callers = self.stats[func]
  291.         c = `nc`
  292.         if nc != cc:
  293.             c = c + '/' + `cc`
  294.         print string.rjust(c, 9),
  295.         print f8(tt),
  296.         if nc == 0:
  297.             print ' '*8,
  298.         else:
  299.             print f8(tt/nc),
  300.         print f8(ct),
  301.         if cc == 0:
  302.             print ' '*8,
  303.         else:
  304.             print f8(ct/cc),
  305.         print func_std_string(func)
  306.  
  307.  
  308.     def ignore(self):
  309.         pass # has no return value, so use at end of line :-)
  310.  
  311.  
  312. #**************************************************************************
  313. # class TupleComp Documentation
  314. #**************************************************************************
  315. # This class provides a generic function for comparing any two tuples.
  316. # Each instance records a list of tuple-indicies (from most significant
  317. # to least significant), and sort direction (ascending or decending) for
  318. # each tuple-index.  The compare functions can then be used as the function
  319. # argument to the system sort() function when a list of tuples need to be
  320. # sorted in the instances order.
  321. #**************************************************************************
  322. class TupleComp:
  323.     def __init__(self, comp_select_list):
  324.         self.comp_select_list = comp_select_list
  325.  
  326.     def compare (self, left, right):
  327.         for index, direction in self.comp_select_list:
  328.             l = left[index]
  329.             r = right[index]
  330.             if l < r:
  331.                 return -direction
  332.             if l > r:
  333.                 return direction
  334.         return 0
  335.  
  336.         
  337.  
  338. #**************************************************************************
  339.  
  340. def func_strip_path(func_name):
  341.     file, line, name = func_name
  342.      return os.path.basename(file), line, name
  343.  
  344. def func_get_function_name(func):
  345.     return func[2]
  346.  
  347. def func_std_string(func_name): # match what old profile produced
  348.     file, line, name = func_name
  349.     return file + ":" + `line` + "(" + name + ")"
  350.  
  351. def func_split(func_name):
  352.     return func_name
  353.  
  354. #**************************************************************************
  355. # The following functions combine statists for pairs functions.
  356. # The bulk of the processing involves correctly handling "call" lists,
  357. # such as callers and callees. 
  358. #**************************************************************************
  359.  
  360.     # Add together all the stats for two profile entries
  361. def add_func_stats(target, source):                
  362.     cc, nc, tt, ct, callers = source
  363.     t_cc, t_nc, t_tt, t_ct, t_callers = target
  364.     return (cc+t_cc, nc+t_nc, tt+t_tt, ct+t_ct, \
  365.           add_callers(t_callers, callers))
  366.  
  367.  
  368.     # Combine two caller lists in a single list.
  369. def add_callers(target, source):
  370.     new_callers = {}
  371.     for func in target.keys():
  372.         new_callers[func] = target[func]
  373.     for func in source.keys():
  374.         if new_callers.has_key(func):
  375.             new_callers[func] = source[func] + new_callers[func]
  376.         else:
  377.             new_callers[func] = source[func]
  378.     return new_callers
  379.  
  380.      # Sum the caller statistics to get total number of calls recieved
  381. def count_calls(callers):
  382.     nc = 0
  383.     for func in callers.keys():
  384.         nc = nc + callers[func]
  385.     return nc
  386.  
  387. #**************************************************************************
  388. # The following functions support printing of reports
  389. #**************************************************************************
  390.  
  391. def f8(x):
  392.     return string.rjust(fpformat.fix(x, 3), 8)
  393.  
  394.  
  395.